package com.sky.chapter3.lock;


import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author : wushikai
 * <p>
 * date : 2022-07-04
 * ReentrantLock获取锁的过程是可中断的
 * 对于synchronized关键字，如果一个线程在等待获取锁，最终只有2种结果：
 * <p>
 * 要么获取到锁然后继续后面的操作
 * 要么一直等待，直到其他线程释放锁为止
 * 而ReentrantLock提供了另外一种可能，就是在等待获取锁的过程中（发起获取锁请求到还未获取到锁这段时间内）是可以被中断的，
 * 也就是说在等待锁的过程中，程序可以根据需要取消获取锁的请求。有些使用这个操作是非常有必要的。
 * 比如：你和好朋友越好一起去打球，如果你等了半小时朋友还没到，突然你接到一个电话，朋友由于突发状况，
 * 不能来了，那么你一定回家。中断操作正是提供了一套类似的机制，
 * 如果一个线程正在等待获取锁，那么它依然可以收到一个通知，被告知无需等待，可以停止工作了
 */
public class LockDemo2 {

    private static ReentrantLock lock1 = new ReentrantLock(false);
    private static ReentrantLock lock2 = new ReentrantLock(false);

    private static class T extends Thread {
        int lockNum;

        T(String name, int lockNum) {
            super(name);
            this.lockNum = lockNum;
        }

        @Override
        public void run() {
            try {
                if (this.lockNum == 1) {
                    lock1.lockInterruptibly();
                    TimeUnit.SECONDS.sleep(1);  //线程等待, 让 线程 获取锁;
                    lock2.lockInterruptibly();
                } else {
                    lock2.lockInterruptibly();
                    TimeUnit.SECONDS.sleep(1);
                    lock1.lockInterruptibly();
                }
            } catch (InterruptedException e) {
                System.out.println("中断标志:" + this.isInterrupted());
                e.printStackTrace();
            } finally {
                if (lock1.isHeldByCurrentThread()) {
                    lock1.unlock();
                }
                if (lock2.isHeldByCurrentThread()) {
                    lock2.unlock();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T t1 = new T("t1", 1);  //获得锁1
        T t2 = new T("t2", 2);  //获得锁2
        t1.start();
        t2.start();
        TimeUnit.SECONDS.sleep(5);
        t2.interrupt();
    }
}
